# 请补充你的代码
width = int(input())
long = int(input())
s = width * long
print(s)



# 请补充你的代码
width = float(input())
long = float(input())
s = width * long
print(s)



# 请补充你的代码
width = eval(input())
long = eval(input())
s = width * long
print(s)



# 请补充你的代码
width = float(input())
long = float(input())
s = width * long
print(round(s,3))



# 请补充你的代码
width = float(input())
long = float(input())
s = width *long
print(f'{s:.2f}')



# 请补充你的代码
long = float(input())
width = float(input())
s = width * long
print(f'长为{long}宽为{width}的矩形面积为{s:.2f}')



import math  
# 地球半径，单位千米  
radius_km = 6371  
# 地球表面积计算公式，单位平方千米  
surface_area_km2 = 4 * math.pi * radius_km ** 2  
# 转换单位到万平方千米  
surface_area_wan_km2 = surface_area_km2 / 10000  
# 格式化输出结果，保留最多小数点后4位  
print(f'地球表面积为{surface_area_wan_km2:.4f}万平方千米')



# 请补充你的代码
import math
r = 6371
v= (4/3)*math.pi*r**3/10000
print(f'地球体积为{v:.4f}万立方千米')



# 请补充你的代码
import math
r = 6371
L = 2 *math.pi*r
print(f'地球赤道周长为{L:.4f}千米')



# 请补充你的代码
import math
a = 0.1
r = 6371
L = 2*math.pi*r+1
r1 = L/2/math.pi
h = r1-r
print(f'空隙大小为{h:.3f}米')
if a<=h:
  print('老鼠可以从空隙中钻过')
else:
  print('老鼠无法通过空隙')



# 请补充你的代码
import math
r = 6371000
p = 5507.85
v = 4/3*math.pi*r**3
m=p*v
n=p*v/(10**15)
print(f'地球质量约为{n:.1f}万亿吨')
print(f'地球质量约为{m:e}千克')

import math
AB = float(input())  # 弦长度
CD = float(input())  # 弓高度
############Begin###############
# 半弦长
AD = AB/2
# 半径
OA =(AD**2+CD**2)/(2*CD)
print(f'{OA:.2f}')
############End###############



import math
AB = float(input())  # 弦长度
CD = float(input())  # 弓高度
# 圆心角
AOB = 2 * math.asin(AD / OA)
# 弓形所在扇形的面积
sector = (AOB)/2/math.pi*math.pi*OA**2
# 三角形面积
triangle = (1/2)*OA**2*math.sin(AOB)
# 弓形面积
area_of_arch = sector - triangle

print(f'{area_of_arch:.2f}')
################End######################



# 请在下面补充你的代码
import math
b1 = 30
h1 = 15
b2 = (78*2+1)/2
h2 = (13*9+7)/9
s1 = 1/2*(b1*h1+h1**2)
s2 = float(1/2*(b2*h2+h2**2))
mu_s1 = s1 / 240
mu_s2 = float(s2 / 240)
mu_int1 = int(mu_s1)
mu_int2 = int(mu_s2)
square_step1 = float((mu_s1 - mu_int1) * 240)
square_step2 = float((mu_s2 - mu_int2) * 240)
print(f'弓形田地面积为{mu_int1}亩零{square_step1:.2f}平方步')
print(f'弓形田地面积为{mu_int2}亩零{square_step2:.2f}平方步')



# 请在下面补充你的代码
import math
b = float(input())
h = float(input())
s = 1/2*(b*h+h**2)
mu_s = s / 240
mu_int = int(mu_s)
square_step = float((mu_s - mu_int) * 240)
print(f'弓形田地面积为{mu_int}亩零{square_step:.2f}平方步')



# 请在下面补充你的代码
import math
AB = float(input())
CD = float(input())
s = 1/2*(AB*CD+CD**2)
mu_s = s / 240
mu_int1 = int(mu_s)
square_step1 = float((mu_s - mu_int1) * 240)
print(f'弧田法计算弓形田地面积为{mu_int1}亩零{square_step1:.2f}平方步')
AD = AB/2
OA = (AD**2+CD**2)/(2*CD)
AOB = 2*math.asin(AD/OA)
sector = AOB/2/math.pi*math.pi*OA**2
triangle = 1/2*OA**2*math.sin(AOB)
arch = sector - triangle
mu_arch = arch / 240
mu_int2 = int(mu_arch)
square_step2 = float((mu_arch - mu_int2) * 240)
print(f'现代方法计算弓形田地面积为{mu_int2}亩零{square_step2:.2f}平方步')



# 请在下面补充你的代码
a = float(input())
r = float(input())
s = a*r/4
mu_s = s / 240
mu_int = int(mu_s)
square_step = float((mu_s - mu_int) * 240)
print(f'宛田法计算扇形田地面积为{mu_int}亩零{square_step:.2f}平方步')



# 请在下面补充你的代码
import math
a=float((11-3*math.sqrt(3))/2)
b=float((11-4*math.sqrt(3))/2)
c=float((9-3*math.sqrt(3))/2)
d=float((9-4*math.sqrt(3))/2)
AB=2
CD=float(2-math.sqrt(3))
s=AB+CD**2/2
print(f'a={a:.4f},b={b:.4f},c={c:.4f},d={d:.4f}')
print(f'会圆法计算弧长为{s:.4f}')



# 请在下面补充你的代码
import math
r = int(input())
AOB = int(input())
l = AOB*math.pi*r/180
print(f'弧长为{l:.2f}')



# 请补充你的代码
a = float(input("请输入第一个数字："))
b = float(input("请输入第二个数字："))
print(f'和：{a+b:.2f}')
print(f'差：{a-b:.2f}')
print(f'积：{a*b:.2f}')
print(f'商：{a/b:.2f}')



# 请补充你的代码
v = float(input("请输入当前速度（米/秒）："))
s = float(input("请输入障碍物距离（米）："))
a = float(input("请输入车辆最大制动加速度（米/秒²）："))
braking_distance = (v**2)/(2*a)
print(f'制动距离为：{braking_distance:.2f} 米')
if braking_distance<=s:
    print('安全：车辆不会撞上障碍物。')
else:
    print('警告：车辆将会撞上障碍物！')



# 请补充你的代码
import math
r = 6371.0
def deg2rad(deg):  
    return deg * (math.pi/180)
def haversine(lon1, lat1, lon2, lat2):  
    # 将十进制度数转化为弧度  
    lon1, lat1, lon2, lat2 = map(deg2rad, [lon1, lat1, lon2, lat2]) 
    # haversine公式  
    dlon = lon2 - lon1   
    dlat = lat2 - lat1   
    a = math.sin(dlat/2)**2 + math.cos(lat1) * math.cos(lat2) * math.sin(dlon/2)**2  
    c = 2 * math.atan2(math.sqrt(a), math.sqrt(1-a))  
    distance = r * c  
    return distance 
lat1 = float(input("请输入第一个点的纬度（度）："))  
lon1 = float(input("请输入第一个点的经度（度）："))
lat2 = float(input("请输入第二个点的纬度（度）："))  
lon2 = float(input("请输入第二个点的经度（度）："))
# 计算两点之间的距离  
distance = haversine(lon1, lat1, lon2, lat2) 
# 格式化并输出距离，保留两位小数  
print(f"两点之间的距离为：{distance:.2f} 公里")



# 补充你的代码
import ast  
# 假设用户输入的字符串存储在变量input_str中  
input_str = input()
# 使用ast.literal_eval安全地将字符串转换为列表  
try:  
    my_list = ast.literal_eval(input_str)  
except ValueError:  
    print("输入的字符串不是一个有效的列表表示。")  
    exit()
# 初始化求和变量  
total_sum = 0
# 遍历列表，尝试将元素转换为整数并求和  
for item in my_list:  
    try:  
        # 尝试将元素转换为整数  
        total_sum += int(item)  
    except ValueError:  
        # 如果转换失败（即不是数值字符串），则跳过  
        continue
# 输出求和结果  
numeric_list = [int(item) for item in my_list if item.isdigit()]  
print(numeric_list) 
print(total_sum)



# 补充你的代码
# 用户输入的字符串  
input_str = input()   
items = input_str.split()  
total_sum = 0  
# 遍历切分后的列表，尝试将元素转换为整数并求和  
for item in items:  
    try:  
        # 尝试将元素转换为整数  
        total_sum += int(item)  
    except ValueError:  
        # 如果转换失败（即不是数值字符串），则跳过  
        continue  
# 输出求和结果  
print(total_sum)



import math
def min_pizzas_needed(m, n):  
    k = math.ceil(m**2 / n**2)  
    return k  
   
m = int(input())  
n = int(input())  
   
result = min_pizzas_needed(m, n)  
print(result)



import math
a = float(input())
b = float(input())
c = float(input())
l = a+b+c
s = l/2
area = math.sqrt(s*(s-a)*(s-b)*(s-c))
print(f'周长={l:.2f}')
print(f'面积={area:.2f}')



import math
a = eval(input())
b = eval(input())
x = ((-1)*b+math.sqrt(2*a*math.sin(math.radians(60))*math.cos(math.radians(60))))/2/a
print(f'{x:.2f}')



import math
a = float(input())
b = float(input())
c = float(input())
x = ((-1)*b+math.sqrt(b**2-4*a*c))/2/a
print(f'{x:.2f}')



length = eval(input())
width = eval(input())
s = length*width
print(s)



p = int(input())
n = int(input())
i = float(input())
F = p*(1+i)**n
m = F-p
print(f'利息={m:.2f}')



def abs_same_type(n):  
    # 检查n是否为整数  
    if isinstance(n, int):  
        # 如果是整数，使用abs函数并强制转换为int（实际上abs对于整数已经返回整数，但这里为了明确）  
        return int(abs(n))  
    # 检查n是否为浮点数  
    elif isinstance(n, float):  
        # 如果是浮点数，直接使用abs函数（abs对于浮点数已经返回浮点数）  
        return abs(n)  
    else:  
        # 如果n不是整数或浮点数，可以抛出一个异常或返回一个错误消息  
        raise ValueError("输入必须是一个整数或浮点数")  
   
n = eval(input())
print(abs_same_type(n))



# 输入行驶里程和等待时间，数字间以半角逗号分隔  
input_str = input()  
mileage, waiting_time = map(int, input_str.split(','))  
  
# 初始化车费  
fare = 0  
  
# 计算起步费  
if mileage <= 3:  
    fare = 13  
else:  
    # 起步费  
    fare += 13  
      
    # 3~15公里的费用  
    if 3 < mileage <= 15:  
        fare += (mileage - 3) * 2.3  
    # 超过15公里的费用  
    else:  
        fare += (15 - 3) * 2.3  # 15公里内的费用  
        fare += (mileage - 15) * 2.3 * 1.5  # 超过15公里的费用
  
# 等待时间费用  
fare += waiting_time  
  
# 输出车费  
print(int(fare))



def sum_of_squares(n):  
    # 初始化平方和为0  
    square_sum = 0  
    # 遍历从1到n的每一个数  
    for i in range(1, n + 1):  
        # 将当前数的平方加到平方和上  
        square_sum += i ** 2  
    # 返回平方和  
    return square_sum  
   
n = int(input())  
print(sum_of_squares(n))



def fibonacci(n):  
    # 初始化斐波那契数列的前两项  
    if n <= 0:  
        return 0  
    elif n == 1 or n == 2:  
        return 1  
    # 使用循环计算斐波那契数列的第n项  
    a, b = 1, 1  
    for i in range(3, n + 1):  
        a, b = b, a + b  
    return b
def main():  
    # 用户输入月份数  
    month = int(input())  
    # 计算该月的兔子总对数  
    rabbits = fibonacci(month)  
    # 如果月份数大于1，则计算前一个月与本月兔子数量的比值  
    if month > 1:  
        prev_month_rabbits = fibonacci(month - 1)  
        ratio = prev_month_rabbits / rabbits  
        # 输出结果，保留小数点后三位  
        print(f"{rabbits} {ratio:.3f}")  
    else:  
        # 如果月份数为1，则直接输出兔子对数和比值（这里比值无意义，但为了格式统一，输出0.000）  
        print(f"{rabbits} 0.000")
if __name__ == "__main__":  
    main()



def leibniz_of_pi(error):  
    """接收用户输入的浮点数阈值为参数，使用莱布尼茨公式返回圆周率值的近似值"""  
    pi_approx = 0.0  
    sign = 1  # 用于交替加减  
    term = 1.0  # 当前项的值  
    i = 0  # 项的索引
    while True:  
        if abs(term) < error:  
            break  
        pi_approx += sign * term  
        sign *= -1  # 交替加减  
        i += 2  # 下一项的分母是 i+1  
        term = 1 / (i + 1)  
      
    pi_approx *= 4  # 乘以4得到π的近似值  
    return pi_approx
if __name__ == '__main__':  
    threshold = float(input())  
    print("{:.8f}".format(leibniz_of_pi(threshold)))



import math
pi = (4*math.atan(1/5)-math.atan(1/239))*4
print(pi)



def is_prime(num):  
    """检查一个数是否为素数"""  
    if num <= 1:  
        return False  
    for i in range(2, int(num**0.5) + 1):  
        if num % i == 0:  
            return False  
    return True
def find_max_prime(N):  
    """找到不大于 N 的最大素数"""  
    for num in range(N, 1, -1):  
        if is_prime(num):  
            return num  
    return None  # 如果没有找到（理论上不会发生，因为1是素数，但这里我们排除它）
# 用户输入  
N = int(input())
# 计算并输出结果  
max_prime = find_max_prime(N) 
print(max_prime)



def is_prime(num):  
    """判断一个数是否为素数"""  
    if num <= 1:  
        return False  
    for i in range(2, int(num**0.5) + 1):  
        if num % i == 0:  
            return False  
    return True
def find_primes(n):  
    """找出n以内的所有素数"""  
    primes = []  
    for num in range(2, n + 1):  
        if is_prime(num):  
            primes.append(str(num))  # 将每个素数转换为字符串  
    return ' '.join(primes)  # 使用空格连接素数字符串
n = int(input())  
primes = find_primes(n)  
print(primes)